#pragma once
#include <iostream>
#include <vector>
#include <cassert>
#include <typeinfo>
#include <cstring>
#include <functional>
#include <ctime>
#include <unordered_map>
#include <mutex>
#include <thread>
#include <memory>
#include <any>
#include <condition_variable>

#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <signal.h>

// 定义一个宏,方便打印
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL ERR
#define LOG(level, format, ...)                                                             \
    do                                                                                      \
    {                                                                                       \
        if (level < LOG_LEVEL)                                                              \
            break;                                                                          \
        time_t t = time(nullptr);                                                           \
        struct tm *ltm = localtime(&t);                                                     \
        char tmp[32] = {0};                                                                 \
        strftime(tmp, 31, "%H:%M:%S", ltm);                                                 \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void*)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)
#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

// buffer模块
#define BUFFER_DEFAULT_SIZE 1024

class Buffer
{
private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理
    uint64_t _reader_idx;      // 读偏移
    uint64_t _writer_idx;      // 写偏移
public:
    Buffer()
        : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE)
    {
    }

    // 1.获取当前写入起始地址
    char* Begin()
    {
        return &*_buffer.begin();
    }

    char* WritePosition()
    {
        // _buffer的空间起始地址, 加上写偏移量
        return Begin() + _writer_idx;
    }

    // 2.获取当前读取起始地址
    char* ReadPosition()
    {
        return Begin() + _reader_idx;
    }

    // 3.获取缓冲区末尾空闲空间大小  --  写偏移之后的空闲空间
    uint64_t TailIdleSize()
    {
        return _buffer.size() - _writer_idx; // 总体空间大小减去写偏移
    }

    // 4.获取缓冲区起始空闲空间大小  --  读偏移之前的空闲空间
    uint64_t HeadIdleSize()
    {
        return _reader_idx;
    }

    // 5.获取可读数据大小
    uint64_t ReadAbleSize()
    {
        return _writer_idx - _reader_idx; // 写偏移 - 读偏移
    }

    // 6.将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)   return ;
        // 向后移动的大小,必须小于可读数据大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }

    // 7.将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        // 向后移动的大小,必须小于当前后边的空间空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }

    // 8.确保可写空间足够 (整体空闲空间够了就移动数据, 否则就扩容)
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果末尾空闲空间大小足够, 直接返回
        if (TailIdleSize() >= len)
            return;
        // 末尾空闲空间不够, 则判断加上起始位置的空闲空间大小是否足够, 够了就将数据移动到起始位置
        if (len <= TailIdleSize() + HeadIdleSize())
        {
            // 将数据移动到起始位置
            uint64_t rsz = ReadAbleSize();                            // 把当前数据大小保存其起来
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _reader_idx = 0;                                          // 将读偏移归0
            _writer_idx = rsz;                                        // 将写位置置为可读数据大小,因为当前数据大小就是写偏移量
        }
        else
        {
            // 总体空间不够, 则需要扩容, 不移动数据, 直接给写偏移之后扩容足够空间即可
            DBG_LOG("resize %ld", _writer_idx + len);
            _buffer.resize(_writer_idx + len);
        }
    }

    // 9.写入数据
    void Write(const void* data, uint64_t len)
    {
        // 1.保证有足够的空间
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char* d = (const char*)data;

        // 2.拷贝数据进去
        std::copy(d, d + len, WritePosition());
    }

    void WriteAndPush(const void* data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }

    void WriteString(const std::string& data)
    {
        return Write(data.c_str(), data.size());
    }

    void WriteStringAndPush(const std::string& data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }

    void WriteBuffer(Buffer& data)
    {
        return Write(data.ReadPosition(), data.ReadAbleSize());
    }

    void WriteBufferAndPush(Buffer& data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 10.读取数据
    void Read(void* buf, uint64_t len)
    {
        // 要求获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char*)buf);
    }

    void ReadAndPop(void* buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }

    std::string ReadAsString(uint64_t len)
    {
        // 要求获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }

    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }

    char* FindCRLF()
    {
        char* res = (char*)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }

    // 通常过去一行数据, 这种情况针对是
    std::string GetLine()
    {
        char* pos = FindCRLF();
        if (pos == nullptr)
            return "";

        return ReadAsString(pos - ReadPosition() + 1); // +1是为了把换行字符也取出来
    }

    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 11.清空缓冲区
    void Clear()
    {
        // 只需要把偏移量归0即可
        _reader_idx = 0;
        _writer_idx = 0;
    }
};

// Socket模块
#define MAX_LISTEN 1024

class Socket
{
private:
    int _sockfd;

public:
    Socket()
        : _sockfd(-1)
    {
    }

    Socket(int fd)
        : _sockfd(fd)
    {
    }

    ~Socket()
    {
        Close();
    }

    int Fd()
    {
        return _sockfd;
    }

    // 创建套接字
    bool Create()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("create socket failed!");
            return false;
        }
        return true;
    }

    // 绑定地址信息
    bool Bind(const std::string& ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("bind address failed!");
            return false;
        }
        return true;
    }

    // 开始监听
    bool Listen(int backlog = MAX_LISTEN) // 最大监听数量
    {
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ERR_LOG("socket listen failed!");
            return false;
        }
        return true;
    }

    // 向服务器发起连接
    bool Connect(const std::string& ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("connect server failed!");
            return false;
        }
        return true;
    }

    // 获取新连接
    int Accept()
    {
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0)
        {
            ERR_LOG("socket accept failed!");
            return -1;
        }
        return newfd;
    }

    // 接受数据
    ssize_t Recv(void* buf, size_t len, int flag = 0)
    {
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 当前socket的接受缓冲区中没有数据了,在非阻塞的情况下才会有这个错误
            // EINTR 表示当前socket的阻塞等待,被信号打断了
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这里接受没有接受到数据
            }
            ERR_LOG("socket recv failed! fd is %d", _sockfd);
            return -1;
        }
        return ret;
    }

    ssize_t NonBlockRecv(void* buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接受非阻塞
    }

    // 发送数据
    ssize_t Send(const void* buf, size_t len, int flag = 0)
    {
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ERR_LOG("socket send failed!");
            return -1;
        }
        return ret; // 实际发送的数据长度
    }

    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)   return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞
    }

    // 关闭套接字
    void Close()
    {
        // if (_sockfd != -1)
        // {
        //     close(_sockfd);
        //     _sockfd = -1;
        // }

        close(_sockfd);
            _sockfd = -1;
    }

    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string& ip = "0.0.0.0", bool flag = false)
    {
        // 1.创建套接字
        if (Create() == false)
            return false;

        // 4.设置非阻塞
        if (flag)
            NonBlock();

        // 2.绑定地址
        if (Bind(ip, port) == false)
            return false;

        // 3.开始监听
        if (Listen() == false)
            return false;

        // 5.启动地址重用
        ReuseAddress();
        return true;
    }

    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string& ip)
    {
        // 1.创建套接字
        if (Create() == false)
            return false;

        // 2.连接服务器
        if (Connect(ip, port) == false)
            return false;
        return true;
    }

    // 设置套接字选项 -- 开启地址端口重用 (服务器关闭之后，会处于一个TimeWait状态，导致无法立刻重启服务器
    // 这里需要开启地址重用，让其可以快速连接)
    void ReuseAddress()
    {
        // int setsockopt(int fd, int leve, int optname, void* val, int vallen)
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
    }

    // 设置套接字阻塞属性 -- 设置为非阻塞
    void NonBlock()
    {
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

// Channel模块
class Poller;
class EventLoop;
class Channel
{
private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被处罚的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被出发的回调函数
public:
    Channel(EventLoop* loop, int fd)
        : _fd(fd), _events(0), _revents(0), _loop(loop)
    {
    }

    int Fd()
    {
        return _fd; // 获取所要监控的文件描述符
    }

    uint32_t Events()
    {
        return _events; // 获取想要监控的事件
    }

    void SetREvents(uint32_t events)
    {
        _revents = events; // 设置实际监控的事件
    }

    // 设置五个事件的回调函数
    void SetReadCallback(const EventCallback &cb)
    {
        _read_callback = cb;
    }
    void SetWriteCallback(const EventCallback &cb)
    {
        _write_callback = cb;
    }
    void SetErrorCallback(const EventCallback &cb)
    {
        _error_callback = cb;
    }
    void SetCloseCallback(const EventCallback &cb)
    {
        _close_callback = cb;
    }
    void SetEventCallback(const EventCallback &cb)
    {
        _event_callback = cb;
    }

    // 当前是否监控了可读
    bool ReadAble()
    {
        return _events & EPOLLIN;
    }

    // 当前是否监控了可写
    bool WriteAble()
    {
        return _events & EPOLLOUT;
    }

    // 启动读事件监控  -- 后面会增加到EventLoop的事件监控中
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }

    // 启动写事件监控  -- 后面会增加到EventLoop的事件监控中
    void EnableWrite()
    {

        _events |= EPOLLOUT;
        Update();
    }

    // 关闭读事件监控  -- 后面会增加到EventLoop的事件监控中
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }

    // 关闭写事件监控  -- 后面会增加到EventLoop的事件监控中
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }

    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }

    // 移除监控
    void ReMove();

    void Update();

    // 事件处理,一旦连接出发了事件,就调用这个函数,自己出发了什么事件,如何处理自己决定
    void HandleEvent()
    {
        if((_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            std::cout << "-------------------------------" << std::endl;
        }

        if ((_revents & EPOLLIN) )
            // 不管什么事件触发了,都调用的回调函数
            if (_read_callback)
                _read_callback();

        // 有可能会释放连接的操作事件,一次只处理一个  一起处理的话,处理一个导致连接关闭,后边就会崩溃的
        if (_revents & EPOLLOUT)
            if (_write_callback)
                _write_callback();
        else if (_revents & EPOLLERR) // 一旦出错,就会释放连接,没必要调用任意回调了,因此要放到前边调用任意回调
            if (_error_callback)
                _error_callback();
        else if (_revents & EPOLLHUP)
            if (_close_callback)
                _close_callback();

        if (_event_callback) // 放在事件处理完毕之后调用,刷新活跃度
                _event_callback();
    }
};

// Poller模块
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel*> _channels;
private:
    // 针对epoll的直接操作(添加,修改,移除)
    void Update(Channel *channel, int op)
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ERR_LOG("epollctl failed! %d", fd);
        }
        return;
    }

    // 判断一个Channel是否添加了事件监控
    bool HasChannel(Channel* channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
            return false;
        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            ERR_LOG("epoll crate error");
            abort(); // 退出程序
        }
    }

    // 添加或者修改监控事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }

        return Update(channel, EPOLL_CTL_MOD);
    }

    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
            _channels.erase(it);
        Update(channel, EPOLL_CTL_DEL);
    }

    // 开始监控,返回活跃连接
    void Poll(std::vector<Channel*>* active)
    {
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            if (errno == EINTR)
                return;
            ERR_LOG("epoll wait error: %s\n", strerror(errno));
            abort(); // 退出程序
        }

        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际就绪的事件
            active->push_back(it->second);
        }
    }
};

// EventLoop模块
// 时间轮
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;

class TimerTask
{
private:
    uint64_t _id;         // 给定时任务对象ID
    uint32_t _timeout;    // 定时任务的超时时间
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息
    bool _canceled;       // false -> 表示没有被取消   true -> 表示任务被取消

public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb)
        : _id(id), _timeout(delay), _task_cb(cb), _canceled(false)
    {
    }

    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _release();
    }

    void SetRelease(const ReleaseFunc &cb)
    {
        _release = cb;
    }

    uint32_t DelayTime()
    {
        return _timeout;
    }

    void Cancel()
    {
        _canceled = true;
    }
};

class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;                                // 当前的秒针, 走到哪里就释放哪里, 释放哪里,就相当于执行哪里的任务
    int _capacity;                            // 表盘的最大数量 -- 起始就是最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel; // 时间轮数组
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop *_loop;
    int _timerfd; // 定时器描述符 -- 可读时间回调就是读取计数器,执行定时任务
    std::unique_ptr<Channel> _timer_channel;
private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
            _timers.erase(it);
    }

    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("timerfd_create error");
            abort();
        }

        struct itimerspec itime;
        // 设置第一次超时时间
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
        // 设置第一次之后,每次超时的时间
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, nullptr); // 使用0为相对时间
        return timerfd;
    }

    int ReadTimerfd()
    {
        uint64_t times; // 8个字节
        // 有可能因为其他描述符的事件处理花费时间比较长,然后在处理定时器描述符时间的时候,有可能就已经超时了很多次
        // read读取去的数据就是上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            ERR_LOG("read timerfd error");
            abort();
        }
        return times;
    }

    // 这个函数应该每秒钟被执行一次,相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组, 就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }

    void OnTime()
    {
        int times = ReadTimerfd();
        for (int i = 0; i < times; i++)
            RunTimerTask();
    }

    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) // 添加定时任务
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }

    void TimerRefreshInLoop(uint64_t id) // 刷新/延迟 定时任务
    {
        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来,添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())
            return; // 没找到,直接返回

        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
            return; // 没找到,直接返回
        PtrTask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }
public:
    TimerWheel(EventLoop* loop)
        : _capacity(60), _tick(0), _wheel(_capacity),
         _loop(loop),_timerfd(CreateTimerfd()),_timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead();
    }

    // 定时器中有个_timers成员,定时器信息的操作有可能在多线程中进行,因此需要考虑线程安全问题
    // 如果不想加锁,那就把定时器的所有操作,都放到一个线程中进行
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);

    // 存在线程安全问题  ->  这个接口不能被外界使用者调用,只能在模块内,在对应的EventLoop线程内执行
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
            return false; // 没找到,直接返回
        return true;
    }
};

// EventLoop模块
class EventLoop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _thread_id; // 线程id
    int _event_fd;              // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller;              // 进行所有描述符的事件监控
    std::vector<Functor> _tasks; // 任务池  用数组模拟队列
    std::mutex _mutex;           // 保证任务池的线程安全
    TimerWheel _timer_wheel; // 定时器模块
public:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for (auto &f : functor)
            f();
    }

    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); // 0 -> 计数器的初始值   EFD_CLOEXEC -> 不可拷贝
        if (efd < 0)
        {
            ERR_LOG("create eventfd failed!");
            abort(); // 程序异常退出
        }

        return efd;
    }

    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            if (errno == EINTR || errno == EAGAIN) // EINTR -> 被信号打断  EAGAIN -> 无数据可读
                return;
            ERR_LOG("read evenfd failed!");
            abort();
        }
        return;
    }

    void WeakUpEventfd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR) // EINTR -> 被信号打断  EAGAIN -> 无数据可读
                return;
            ERR_LOG("read evenfd failed!");
            abort();
        }
        return;
    }

public:
    EventLoop()
        : _thread_id(std::this_thread::get_id()), _event_fd(CreateEventFd())
        , _event_channel(new Channel(this, _event_fd))
        ,_timer_wheel(this)
    {
        // 给Eventfd添加可读事件回调函数,读取eventf事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }

    // 启动EventLoop模块  三步走 ---> 事件监控  ---> 就绪时间处理   --->  执行任务
    void Start()
    {
        while(1)
        {
            // 1.事件监控
            std::vector<Channel*> actives;
            _poller.Poll(&actives);

            // 2.事件处理
            for (auto &channel : actives)
                channel->HandleEvent();

            //  3.执行任务
            RunAllTask();
        }
    }

    // 判断当前线程是否是EventLoop对应的线程
    bool IsInLoop()
    {
        return _thread_id == std::this_thread::get_id();
    }

    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }

    // 判断将要执行的任务是否处理当前线程中,如果是则执行,不是则压入队列
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
            return cb();
        return QueueInLoop(cb);
    }

    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪,而导致的epoll阻塞
        // 其实就给eventfd写入一个数据,eventfd就会触发可读事件
        WeakUpEventfd();
    }

    // 添加或修改描述符的事件监控
    void UpdateEvent(Channel* channel)
    {
        return _poller.UpdateEvent(channel);
    }

    // 移除对描述符的监控
    void RemoveEvent(Channel* channel)
    {
        return _poller.RemoveEvent(channel);
    }

    void TimerAdd(uint64_t id, uint32_t dalye, const TaskFunc& cb)
    {
        return _timer_wheel.TimerAdd(id, dalye, cb);
    }

    void TimerRefresh(uint64_t id)
    {
        return _timer_wheel.TimerRefresh(id);
    }

    void TimerCancel(uint64_t id)
    {
        return _timer_wheel.TimerCancel(id);
    } 

    bool HasTimer(uint64_t id)
    {
        return _timer_wheel.HasTimer(id);
    }
};

// LoopThread模块
class LoopThread
{
private:
    // 用于实现_loop获取的同步关系,避免线程创建了,但是_loop还没有实例化之前去获取_loop
    std::mutex _mutex; // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop* _loop;  // EventLoop指针变量,这个对象需要在线程内实例化
    std::thread _thread; //EventLoop对应的线程
private:
    // 实例化EventLoop对象,唤醒_cond上有可能阻塞的线程,并且开始运行EventLoop模块的功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);   // 上锁
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }
public:
    // 创建线程, 设置线程入口函数
    LoopThread()
        :_loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this))
    {}

    // 返回当前线程关联的EventLoop对象指针
    EventLoop* GetLoop()
    {
        EventLoop* loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);   // 上锁
            _cond.wait(lock, [&](){ return _loop != nullptr;});  // _loop为空就一直阻塞
            loop = _loop;
        }
        return loop;
    }
};

// LoopThreadPool
class LoopThreadPool
{
private:
    int _thread_count;
    int _next_idx;
    EventLoop* _baseloop;
    std::vector<LoopThread*> _threads;
    std::vector<EventLoop*> _loops;
public:
    LoopThreadPool(EventLoop* baseloop)
        :_thread_count(0), _next_idx(0), _baseloop(baseloop)
    {}

    void SetThreadCount(int count)
    {
        _thread_count = count;
    }

    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
    }

    EventLoop* NextLoop()
    {
        if (_thread_count == 0)
            return _baseloop;
        
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }
};

// Connection模块
class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}

        virtual const std::type_info& type() = 0;

        virtual holder* clone() = 0;
    };

    template<class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T& val)
            :_val(val)
        {}

        virtual const std::type_info& type() override // 过去子类对象保存的数据类型
        {
            return typeid(T);
        }

        virtual holder* clone() override // 针对当前的对象自身, 克隆除一个新的子类对象
        {
            return new placeholder<T>(_val);
        }
    public:
        T _val;
    };
    holder* _content;
public:
    Any()
        :_content(nullptr)
    {}

    template<class T>
    Any(const T& val)
        :_content(new placeholder<T>(val))
    {}

    Any(const Any& other)
        :_content(other._content ? other._content->clone() : nullptr)
    {}

    ~Any()
    {
        delete _content;
    }

    Any& swap(Any& other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    template<class T>
    T* get()  // 返回子类对象保存的数据指针
    {
        // 要获取的数据类型必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
            
        return &((placeholder<T>*)_content)->_val;
    }

    template<class T>
    Any& operator=(const T& val)   // 赋值运算符的重载函数
    {
        // 给val构造一个临时对象,和我们当前的容器进行指针交换,临时对象释放的时候,原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }

    Any& operator=(const Any& other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

class Connection;
typedef enum  // connection的状态
{
    DISCONNECTED, // 连接关闭状态
    CONNECTING,  // 连接建立成功 -- 待处理状态
    CONNECTED,  // 连接建立完成,各种设置完成,可以通信的状态
    DISCONNECTING   // 待关闭的状态
} ConnStatu;

using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID,便于连接的管理和查找
    // uint64_t _timer_id;  // 定时器的ID,必须是唯一的,这块为了简化操作使用conn_id作为定时器ID
    int _sockfd; // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志, 默认为false
    EventLoop* _loop; // 连接所关联的一个EventLoop
    ConnStatu _statu; // Connection的连接状态
    Socket _socket; // 套接字的操作管理
    Channel _channel; // 连接的事件管理
    Buffer _in_buffer; // 输入缓冲区 -- 存放的是从socket中读取到的数据
    Buffer _out_buffer; // 输出缓冲区 -- 存放要放松给对端的数据 
    Any _context; // 请求的接受处理上下文

    //  这四个回调函数, 是让服务器模块来设置的 (其实服务器模块的处理回调也是组件使用者设置的)
    // 这几个回调都是组件使用者使用的
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void (const PtrConnection&, Buffer*)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    // 组件内的连接关闭回调 -- 组件内设置的,因为服务器组件内会把所有的连接管理起来,一旦某个连接要关闭
    // 就应该从管理的地方移除掉自己的信息
    ClosedCallback _server_closed_callback;
private:
    // 五个chennel的事件回调函数
    // 描述符可读事件触发后调用的函数,接受socket数据放到接受缓冲区中,然后调用 _message_callback;
    void HandleRead()
    {
        // 1.接受socket的数据,放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0)
            return ShutdownInLoop();  // 出错了, 不能直接关闭
        // 这里等于0,代表没有数据,而并不是连接断开了,连接断开返回的是-1
        // 将数据放入输入缓冲区,写入之后顺便写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);

        // 2.调用message_callback进行业务处理
        if (_in_buffer.ReadAbleSize() > 0)
            // shared_from_this -- 从当前对象自身获取自身的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        
    }
    // 描述符可写事件触发后调用的函数, 将发送缓冲区的数据进行发送
    void HandleWrite()
    {
        // _out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了
            if (_in_buffer.ReadAbleSize() > 0)
                _message_callback(shared_from_this(), &_in_buffer);
            return Release();
        }
        _out_buffer.MoveReadOffset(ret); // 千万不要忘了,将都位置向后偏移
        if (_out_buffer.ReadAbleSize() == 0)
        {
            _channel.DisableWrite(); // 没有数据待发送了,关闭写事件监控

            // 如果当前是连接待关闭状态,则有数据,发送完数据释放连接,没有数据则直接释放
            if (_statu == DISCONNECTING)
                return Release();
        }    
    }
    // 描述符触发挂断事件
    void HandleClose()
    {
        // 一旦连接挂断了,套接字就什么都干不了了,因此有数据待处理一下,完毕关闭连接
        if (_in_buffer.ReadAbleSize() > 0)
            _message_callback(shared_from_this(), &_in_buffer);
        return Release();
    }
    // 描述符触发错误事件
    void HandleError()
    {
        return HandleClose();
    }

    // 触发任意事件: 1.刷新连接的活跃度 --  延迟定时销毁任务   2.调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
            _loop->TimerRefresh(_conn_id);
        if (_event_callback)
            _event_callback(shared_from_this());
    }

    // 连接获取之后,所处的状态下要进行各种设置(启动都监控, 调用回调函数)
    void EstablishedInLoop()
    {
        // 1.修改连接状态
        assert(_statu == CONNECTING); // 当前的状态一定是上层的半连接状态
        _statu = CONNECTED; // 当前函数执行完毕,则连接进入已完成连接状态
        // 一旦启动读事件监控极有可能立即触发读事件,如果这时候启动了非活跃连接销毁

        // 2.启动读事件监控
        _channel.EnableRead();

        // 3.调用回调函数
        if (_connected_callback)   _connected_callback(shared_from_this());
    }

    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1.修改连接状态,将其置为DISCONNECTED
        _statu = DISCONNECTED;

        // 2.移除连接的事件监控
        _channel.ReMove();

        // 3.关闭描述符
        _socket.Close();

        // 4.如果当前定时器队列中还有定时销毁任务,则取消任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();

        // 5.调用关闭回调函数, 避免先移除服务器管理的信息导致Connection被释放,再去处理会出错,因此先调用用户的回调函数
        if (_closed_callback)   _closed_callback(shared_from_this());

        // 移除服务器内部管理的连接信息
        if (_server_closed_callback) _server_closed_callback(shared_from_this());
    }

    // 这个接口并不是实际的发送接口,而只是把数据放到了发送缓冲区,启动了可写事件监控
    void SendInLoop(Buffer& buf)
    {
        if (_statu == DISCONNECTED) return ;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
            _channel.EnableWrite();
    }

    // 这个关闭操作,并不是实际的连接释放操作,需要判断还有没有数据待处理,待发送
    void ShutdownInLoop()
    {
        _statu = DISCONNECTING; // 设置为半连接关闭状态
        if (_in_buffer.ReadAbleSize() > 0)
            if(_message_callback)   _message_callback(shared_from_this(), &_in_buffer);
        
        // 要么就是写入数据的时候出错关闭,要么就是没有待发送数据,直接关闭
        if (_out_buffer.ReadAbleSize() > 0)
            if (_channel.WriteAble() == false)
                _channel.EnableWrite();
        
        if (_out_buffer.ReadAbleSize() == 0)
            Release();
    }
    
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1.将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2.如果当前定时销毁任务已经存在,那就刷新一下延迟即可
        if (_loop->HasTimer(_conn_id))
            return _loop->TimerRefresh(_conn_id);
        // 3.如果不存在定时任务,那就添加定时销毁任务
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }

    // 取消定时任务
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
            _loop->TimerCancel(_conn_id);
    }

    void UpgradeInLoop(const Any& context, 
                        const ConnectedCallback& conn,
                        const MessageCallback& msg,
                        const ClosedCallback& closed,
                        const AnyEventCallback& event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }
public:
    Connection(EventLoop* loop, uint64_t conn_id, int sockfd)
        :_conn_id(conn_id),_sockfd(sockfd)
        ,_enable_inactive_release(false),_loop(loop), _statu(CONNECTING)
        ,_socket(_sockfd), _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }

    ~Connection()
    {
        DBG_LOG("release connection:%p", this);
    }

    // 获取管理的文件描述符
    int Fd()
    {
        return _sockfd;
    }

    // 获取连接ID
    int Id()
    {
        return _conn_id;
    }

    // 是否处于连接状态
    bool Connnected()
    {
        return _statu == CONNECTED;
    }

    // 设置上下文 -- 连接建立完成时进行调用
    void SetContext(const Any& context)
    {
        _context = context;
    }

    // 获取上下文信息,返回的是指针
    Any* GetContext()
    {
        return &_context;
    }

    // 设置回调函数
    void SetConnectedCallback(const ConnectedCallback& cb)
    {
        _connected_callback = cb;
    }
    void SetMessageCallback(const MessageCallback& cb)
    {
         _message_callback = cb;
    }
    void SetClosedCallback(const ClosedCallback& cb)
    {
         _closed_callback = cb;
    }
    void SetAnyEventCallback(const AnyEventCallback& cb)
    {
         _event_callback = cb;
    }
    void SetSrvClosedCallback(const ClosedCallback& cb)
    {
         _server_closed_callback = cb;
    }

    // 连接建立就绪后, 进行Channel回调设置,启动读监控,调用_connected_callback
     void Established()
     {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
     }

    // 发送数据,将数据放到发送缓冲区,启动写事件监控
    void Send(const char* data, size_t len)
    {
        // 外界传入的data,可能是个临时的空间,我们现在只是把发送操作压入了任务池,有可能没有被立即执行
        // 因此有可能执行的时候,data指向的空间有可能已经被释放了
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }

    // 提供给组件使用者的关闭接口  -- 并不实际关闭,需要判断有没有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 启动非活跃销毁,并定义多长时间无通信就是非活跃,添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }

    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }

    // 切换协议 -- 重置上下文以及阶段性回调处理函数  -- 非线程安全  必须在本线程内调用
    // 防止新的事件触发后,处理的时候,切换任务还没有被执行 -- 会导致数据使用原协议处理
    void Upgrade(const Any& context, const ConnectedCallback& conn, const MessageCallback& msg,
                const ClosedCallback& closed, const AnyEventCallback& event)
    {
        _loop->AssertInLoop();  // 这个线程必须在EventLoop线程中立即被执行
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

// Acceptor模块
class Acceptor
{
private:
    Socket _socket; // 用于创建监听套接字
    EventLoop* _loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 用于对监听套接字进行事件管理
    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;
private:
    // 监听套接字的读事件回调处理函数 -- 获取新连接, 调用_accept_callback函数进行新连接的处理
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
            return ;
        if (_accept_callback)
            _accept_callback(newfd);
    }

    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }
public:
    // 不能将启动读事件监控,放到构造函数中,必须在设置回调函数后,再去启动
    // 否则有可能造成启动监控后,立即有事件,处理的时候,回调函数还没有设置,新连接得不到处理,且资源泄漏
    Acceptor(EventLoop* loop, int port)
        :_loop(loop), _socket(CreateServer(port)), _channel(_loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }

    void SetAcceptCallback(const AcceptCallback& cb)
    {
        _accept_callback = cb;
    }

    void Listen()
    {
        _channel.EnableRead();
    }
};

// TcpServer模块
class TcpServer
{
private:
    uint64_t _next_id;  // 这是一个自动增长的的连接Id
    int _port; // 服务器连接的端口
    int _timeout;   // 这是非活跃连接的统计时间 --- 多长时间无通信就是非活跃连接
    bool _enable_inacyive_release; // 是否启动了非活跃连接销毁的判断标志
    Acceptor _acceptor;  // 这是监听套接字的管理对象
    EventLoop _baseloop;   // 这是主线程的EventLoop对象,负责监听事件的管理
    LoopThreadPool _pool;  // 这是从属EventLoop的线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理的所有连接对应的shared_ptr对象

    using Functor = std::function<void()>;
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void (const PtrConnection&, Buffer*)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
private:
    void RunAfterInLoop(const Functor& task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }

    // 为新连接构造一个Connection对象进行管理
    void NewConnection(int fd)
    {
        _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback); 
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        
        if (_enable_inacyive_release) conn->EnableInactiveRelease(_timeout); // 启动非活跃超时销毁
        conn->Established(); // 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const PtrConnection& conn)
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end())
            _conns.erase(it);
    }

    // 从管理的Connection对象_conns中移除连接信息
    void RemoveConnection(const PtrConnection& conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }
public:
    TcpServer(int port)
        :_port(port), _next_id(0), _enable_inacyive_release(false),
        _acceptor(&_baseloop, port), _pool(&_baseloop)
    {
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen(); // 将监听套接字挂到baseLoop上
    }

    void SetThreadCount(int count)
    {
        return _pool.SetThreadCount(count);
    }

    // 设置回调函数
    void SetConnectedCallback(const ConnectedCallback& cb)
    {
        _connected_callback = cb;
    }
    void SetMessageCallback(const MessageCallback& cb)
    {
         _message_callback = cb;
    }
    void SetClosedCallback(const ClosedCallback& cb)
    {
         _closed_callback = cb;
    }
    void SetAnyEventCallback(const AnyEventCallback& cb)
    {
         _event_callback = cb;
    }

    void EnableInactivateRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inacyive_release = true;
    }

    // 用于添加一个定时任务
    void RunAfter(const Functor& task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }

    void start()
    {
        _pool.Create(); // 创建线程池中的从属线程
        return _baseloop.Start();
    }
};

void Channel::ReMove()
{
    return _loop->RemoveEvent(this);
}

void Channel::Update()
{
    return _loop->UpdateEvent(this);
}

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}

void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

class NetWork
{
public:
    NetWork()
    {
        DBG_LOG("SEGPIPE INET");
        signal(SIGPIPE, SIG_IGN);
    }
};
static NetWork nw;
